{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:45.075204500Z",
     "start_time": "2023-09-06T05:30:45.061204200Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium == 0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. Double DQN\n",
    "\n",
    "[van Hasselt et al., \"Deep Reinforcement Learning with Double Q-learning.\" arXiv preprint arXiv:1509.06461, 2015.](https://arxiv.org/pdf/1509.06461.pdf)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Let's take a close look at the difference between DQN and Double-DQN. The max operator in standard Q-learning and DQN uses the same values both to select and to evaluate an action. This makes it more likely to select overestimated values, resulting in overoptimistic value estimates.\n",
    "\n",
    "$$\n",
    "\\theta_{t+1} = \\theta_t + \\alpha \\big(Y_t^Q - Q(S_t, A_t; \\theta_t)\\big) \\cdot \\nabla_{\\theta_t} Q(S_t, A_t; \\theta_t),\\\\\n",
    "\\text{where } \\alpha \\text{ is a scalar step size and the target } Y_t^Q \\text{is defined as }\\\\\n",
    "Y_t^Q = R_{t+1} + \\gamma \\max_a Q(S_{t+1}, a; \\theta_t).\n",
    "$$\n",
    "\n",
    "In Double Q-learning ([van Hasselt 2010](https://papers.nips.cc/paper/3964-double-q-learning.pdf)), two value functions are learned by assigning experiences randomly to update one of the two value functions, resulting in two sets of weights, $\\theta$ and $\\theta'$. For each update, one set of weights is used to determine the greedy policy and the other to determine its value. For a clear comparison, we can untangle the selection and evaluation in Q-learning and rewrite DQN's target as\n",
    "\n",
    "$$\n",
    "Y_t^Q = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t).\n",
    "$$\n",
    "\n",
    "The Double Q-learning error can then be written as\n",
    "\n",
    "$$\n",
    "Y_t^{DoubleQ} = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t').\n",
    "$$\n",
    "\n",
    "The idea of Double Q-learning is to reduce overestimations by decomposing the max operation in the target into action selection and action evaluation. Although not fully decoupled, the target network in the DQN architecture provides a natural candidate for the second value function, without having to introduce additional networks. In conclusion, the weights of the second network $\\theta_t'$ are replaced with the weights of the target network for the evaluation of the current greedy policy. This makes just a small change in calculating the target value of DQN loss.\n",
    "\n",
    "##### DQN:\n",
    "\n",
    "```\n",
    "target = reward + gamma * dqn_target(next_state).max(dim=1, keepdim=True)[0]\n",
    "```\n",
    "\n",
    "##### DoubleDQN:\n",
    "\n",
    "```\n",
    "selected_action = dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "target = reward + gamma * dqn_target(next_state).gather(1, selected_action)\n",
    "```\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:46.399153700Z",
     "start_time": "2023-09-06T05:30:45.067204300Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:46.434818Z",
     "start_time": "2023-09-06T05:30:46.395153900Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:46.435820300Z",
     "start_time": "2023-09-06T05:30:46.411816300Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use `self.dqn` instead of `self.dqn_target` for action selection.\n",
    "\n",
    "```\n",
    "\n",
    "        next_q_value = self.dqn_target(next_state).gather(\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)  # Double DQN\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:46.457817200Z",
     "start_time": "2023-09-06T05:30:46.422816400Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).gather(  # Double DQN\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:46.482816800Z",
     "start_time": "2023-09-06T05:30:46.452817100Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:46.484816600Z",
     "start_time": "2023-09-06T05:30:46.470816800Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:47.449002400Z",
     "start_time": "2023-09-06T05:30:46.485817900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 3 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:31:27.893346500Z",
     "start_time": "2023-09-06T05:31:26.803894100Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\gymnasium\\wrappers\\record_video.py:87: UserWarning: \u001B[33mWARN: Overwriting existing videos at C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\double_q folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001B[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\double_q\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\double_q\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                              "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\double_q\\rl-video-episode-0.mp4\n",
      "score:  141.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/double_q\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:31:27.909346700Z",
     "start_time": "2023-09-06T05:31:27.887347700Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAKXltZGF0AAACoQYF//+d3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMTkgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz0xMiBsb29rYWhlYWRfdGhyZWFkcz0yIHNsaWNlZF90aHJlYWRzPTAgbnI9MCBkZWNpbWF0ZT0xIGludGVybGFjZWQ9MCBibHVyYXlfY29tcGF0PTAgY29uc3RyYWluZWRfaW50cmE9MCBiZnJhbWVzPTMgYl9weXJhbWlkPTIgYl9hZGFwdD0xIGJfYmlhcz0wIGRpcmVjdD0xIHdlaWdodGI9MSBvcGVuX2dvcD0wIHdlaWdodHA9MiBrZXlpbnQ9MjUwIGtleWludF9taW49MjUgc2NlbmVjdXQ9NDAgaW50cmFfcmVmcmVzaD0wIHJjX2xvb2thaGVhZD00MCByYz1jcmYgbWJ0cmVlPTEgY3JmPTIzLjAgcWNvbXA9MC42MCBxcG1pbj0wIHFwbWF4PTY5IHFwc3RlcD00IGlwX3JhdGlvPTEuNDAgYXE9MToxLjAwAIAAAAHDZYiEACf//vWxfApqyfOKDOgyLuGXJMmutiLibQDAACUoUAAAAwASyZQlsyAcmXdAAAATIAOKH0GUHmImKsVAlg2LQcDNRKFOiC+oj2i2gF1QjtMrmkKwe5mO0srzHGhB2w/r63nS/mokpqyDBN9xbf4uPBmqJtwLPmmHeg3lyMCSX2qE8wlghWzoLBpQD5tmfv70iti0KCwjRu1FsAJ1E1E5lJGQPs0Z49AEUJpbMxm06BxxEmOzXg1sXr1xPmnCmh+YMgRSd/KbiF5ctJ8/g4U4GXMoFgmgjF+JpBoX5z4l2p11B5HMhN+NJMz/BmZSWlh9Ph+WArCtC76VoUKaNiCgXl/bgXoWYjmhv52Bp7wjcYmEs2Q3RI1YvfyCyger3bmL0u1uHzBjjUZIFRpOLI0bQc1Z9T/8lnqGoqti+gKxZiDiTwvKufc144YVG6jv0oHm27INVDmzBusLrFBqCacfQxqu3pq5oJm5hMN65UzRfm1cvyXJqQAEVPy2olOZPjaSH5hfkmrQ0cFvunj3+10IiV+Hy5kxVSPzA4r32eduF7D66ZpYjs8yAACqAACm0UNO/QAAAwAAAwAAAwAAAwAQEQAAAKJBmiRsQn/98QAAAwKfXCUIF60qgCBg5e2Yn3+mWTfy1GjoPLQ8uFG8PsEi4MRORiA6qbchwKVu0fia4hTPKTllIQh8m/4OGe+oEv+8CYZfT1OKOhywxukVJD9RSp+uR+AwtzXg2WiyiSQI6E5IvS4GN6h37RD30Q8bIQcXu2bv/vKV6vS5s/ad7U+TfPCTjY7qFnNzaRrK9Pp1rhqZTB5tdiAAAAAyQZ5CeIR/AAAWvkuuMWbr/us3Ojm6h5XcRYZkKzUdJYelr0j8u7iOmtCOnGS828DLUikAAAAeAZ5hdEf/AAAE+9HjgGmuk4yI3nwsq1L3SlE8X2fAAAAAHgGeY2pH/wAAI7HMCW+s7S+0vPekC64knSjwIiSsbwAAAOhBmmhJqEFomUwIT//98QAAAwKe+AR8B/nJpLyxT9wEmClYhqO+eV8Md8ejL1eENLdFb+BHvhjVKQ8bt3Z3evyQiBsG0JbiMxvGROG2ALDjA9kUqke7DPqd4N2lmjE0NVl0ByaHpI9+3TP2ZNzqNwZEh+ow2dmjrRcI0804PSrgJ5omlKLQYdmJJeCEJIVG1LrOSwwPXSmzepVfN1UdvxC7S1dM2rTMXb5DEMg194OXHHBEcMZDmp50Aez7MbTUYCloRmV8fFRHq0u8rz7TGa5saHipBobiGyJTTl9FqB1M1mNnLxjjmPpJAAAAQ0GehkURLCP/AAAWu5RUsPh8MLuQt4DzNEIn21+qZlPu+RIsUH73rKeFzw6ZZWZl557PcI6+Yaz4ABdTNbFY1g7ZPkkAAAA0AZ6ldEf/AAAjq/hZI+ZVt6g4sOcxRZM7yuQt3jIgog1gI0drPEEH7zRnHzby/ooFAXt9sQAAACABnqdqR/8AACOuMS/SfqovyJn1AR8ycpBqAuIaqCGFwAAAAGlBmqxJqEFsmUwIT//98QAAAwKe+iWGYCycEhRxkx8fehQq3N0BWGWn/ZoA2bM9dnU0GVIio+5M2RfSHHnNFD+TkGqXPQMPe1mxKgjJH6KkcsdkR2xoVt9mCnvg9nA1HIS8WBYrrC5B8/AAAABNQZ7KRRUsI/8AABa7lDci95EjzoYpa/edOtuojSg+ZJLckqVG2NPVXor2FMNaxIp74K0RZ6s5wvRVnEALCVCpqPATj1OTESOJWkkMwIEAAAAgAZ7pdEf/AAAjq/hbeBKdaCPG6ntNXyhR83aQ6jxfhswAAAAiAZ7rakf/AAAjscwMv5YTdhnnsnJ2yba9CUsNmHbPbXLRgQAAAExBmvBJqEFsmUwIR//94QAABBNvULni+mjqsmbyeo71JUDv24aO9A+8f4AA3B5FUZz/0TllYkaQyfr+09BFi9fcGU6aaWcy/r/qeKCBAAAANkGfDkUVLCP/AAAWvEPN+Ol25uUALbVEctx5h8Rl3LqqNmO/ONQDp3Cj6l9OOv8T3IaYrelwIQAAACIBny10R/8AAA0uFJq6g4ijuol8HiHue+W+wkpKncBSr5wJAAAAJAGfL2pH/wAAI7HL/FVxO4ZWaCd9AUMWXM2KxW9V9XmQrZaDgAAAAHdBmzRJqEFsmUwIT//98QAAAwKjyfWZG48CSJSPE5cWPxvuKc+TsREYyjRWYy18e+iKrAWcjRGzjjNzmnmyus/4E8KRnpZjLVyvlFXazsNjcJzC7GXxa858l+AF7wKg1bnhR3luUL6z/k9cKhoQ5yY6QHWMXpE7xAAAADpBn1JFFSwj/wAAFruUNyM4ElM2loWt1tQTQTl0+15+QkI163tn27T2g1dwMMI8n8+oAP5syIyzuLwZAAAAJQGfcXRH/wAAI6v4XDZ5/LkdN74Grt06+BCuXMxEQdgLr4bQduAAAAAzAZ9zakf/AAAjsN/ADIbiZrQBfvOlTIMSIGT8qW/ksCyC8bHjRhu2jp/Qibagb43owXwYAAAAV0GbeEmoQWyZTAhH//3hAAADA/U4iGh0TcCbZY0JJm2lcy21g/cA2jfzCRRBSHUD6DukyL9N7CGZqcBxNbAfu12YsoBagvaZn6a7orCapGbu98sAYp2VBwAAAChBn5ZFFSwj/wAAFiKfXw6D8ZYBeoyt9CpsE+HTuEm8JlSOEtHHtkBAAAAAJQGftXRH/wAAIsNHHBKQofH4W4NUtIujRn0HhACXaT/pV/Kb7ZkAAAAoAZ+3akf/AAAirjMFGjnhmF9hOsmiZGrbLpVaUaoZMy7MwVzQPGySYQAAAHBBm7xJqEFsmUwIR//94QAAAwP3ZMxa1ZAQ02/0BuzTlActwgCO7LKj1jGYXwmN/4Zn1e69LiwjWiT9ExFP4o3UobqfekSycVGCoaCdCmBv8WXELzkzMpnGxGN4f68P3TrhXEMPx7OV2dtb/InLu/XQAAAAN0Gf2kUVLCP/AAAWK5RYOzbuExjIXgIKOVXP+cAHJl9uDMgqtvhaUF+BdYRC4sWYA0de6XChrgsAAAAkAZ/5dEf/AAAirDlkLKP1zFUQXlDW7hKxgDUFK9eze9Bvv+8GAAAANQGf+2pH/wAAIr2WAooH5UWECgBJb2tLqrprtBt6qZXOA8k1JHS6sP2axVw988ClBw4MIcFhAAAAYUGb4EmoQWyZTAhH//3hAAADA/U+q+35zixeu9fiMaNqUqo11j5+rbOMriFeZrqGuzs50hABxtR+5Ixl+F5leK2NefhUIBJP92zRbad8cK3H+AabzVN5NmnAVpc4Eyb14F8AAAAqQZ4eRRUsI/8AABYint43G0cL+XQ18ITQH0cZUbl/09n+/+n5FIPfqFT4AAAAKwGePXRH/wAAIsDMu6tDbnYa4Zzc24bIbDaHdG8WYW3dWPXGpVUdxThsQygAAAAnAZ4/akf/AAAirjEv0XlDs822QHw+PKbNnxK78/kSVO9DnMU29KJ9AAAAYkGaJEmoQWyZTAhH//3hAAADA/U+zPwMlU4MqjKNJ8SXxaIyzEAUKj1idN5FhXIJWjVmQAmMQSkUmeDLXdZfjK/Go4A9FN0P0hZzBQ45zuEprZjhxbYx7XUqlImd9RLc1R/AAAAAKEGeQkUVLCP/AAAWIp3IWTO5qdWqz69yQ9kz9FHge3yl22EL9sMR6QsAAAAvAZ5hdEf/AAAiqc7Fk4V0NuStf6SIQt09MiwyAAJ03eqIaCqLPIXB9AxKghlbuCAAAAAiAZ5jakf/AAAirjHRoIWfNQGpOMHeQH2elsmy0sB2nPregQAAAGJBmmhJqEFsmUwIR//94QAAAwP7v+pnDBun3hKtgAFVxgqozN+QgWQjjui+IzKDdiAtbVyalXXI3dtwzFmWqhV+lvzs0p2lqj/E6iB8Mg5WTE8uiWnkx0wQK73jOY5Q64DFqQAAACZBnoZFFSwj/wAAFiUl/UzcVuWerax/7s7RB5mSq8H6epo6mya8WQAAACQBnqV0R/8AACLAuN/BXoNAcYauTrsnrq5+YLQlTycUJEbWrekAAAAjAZ6nakf/AAAhrjMFGZ6tW1zP00CM3BDfefgn4ycn2NeFt6AAAABpQZqrSahBbJlMCEf//eEAAAMD3z8q0QEHA7Ys7bxE3XOyact1kltTnSQjqc51Er0xNvl9BMg2rW6Y4tljVAo1f18BtQT2l0N2cH0nuEQapGmeqK1vHRLjty773HtYDKOeINY/Udnx3V74AAAAKkGeyUUVLCP/AAAVkp6otDzTwtWllEXS+ALm9lRf0JQXhoD+Oomhvch4sQAAACwBnupqR/8AACF6RBlZYJaRGK67+sxAfLStT6U1I91IYYvACTD9320axQIKMAAAAH5Bmu5JqEFsmUwIR//94QAAAwPgg1WwihyAHvgA1GjWz84GK+SrJvq4PPNm5yDYXGCE9n/eXIMY8LsqMOvTcbvX+SSFjQjGpzjM61b2yo0YdSONlcqRE2RZLveC5Xe8IbwPVrBPRpDTaOOs0GQPZoVaf6KW+gcEZC38z9IH0ogAAAA4QZ8MRRUsI/8AABWR/ZELXmnilAALqZwUkqcwo3wpJd6E9SSAbKkVxUdyJwY/ckHSRZPdIsyXy48AAAAvAZ8takf/AAAhrjEcfjoD+A427LXWe3NEKNs+YmtM7tpNf4eHgZX6ugCwuNki5mEAAAA2QZsySahBbJlMCEf//eEAAAMD5b/qZ5Ybp/w+AACq4vyIVs/XVC9XJzVg4bAW7IITCI5tfeqBAAAAK0GfUEUVLCP/AAAVliUiL6imbzyIppMO+Zg9rku1Qu7n4/Es+mnUxdJVJ2wAAAA0AZ9vdEf/AAAhqUB/WSnWT6Yp2kX9NzCuMhNIF/57m/PM1QACdWzP+i3DhF+WL4zuakJ/JgAAADIBn3FqR/8AACGxvmKOfxDRexD4xj9SD/6R09M7l/WGv7Ugl7JsdYyL8LUZtPL50/7yYQAAAFlBm3ZJqEFsmUwIR//94QAAAwPKSHO3Jbf2FAAIvuMrCf64vVPqa2UETpu9SJ1hm5kyPBiJv7XbZ/RqB1LO2JVsNdh4XLEZHlpYZa882TltPc7pwhtSZD0iMAAAAC9Bn5RFFSwj/wAAFQIu8QthNjqX1IAA3U9lR6tEnZ/vD+s604gq/FYkDL9EsonZRgAAADABn7N0R/8AACCpQIe9pshBm7tNTtu5bmBttqoefMEjPamWwVvXhzHl2maeLG8y5IEAAAAnAZ+1akf/AAAgrUXmcOqGgFTW3TPcgBD+7cnDl+RZWEkBxWx84H9YAAAAb0GbukmoQWyZTAhP//3xAAADAm3RNcqco3qxdwFRs2ZMhwaAgP+txWXqP9+padQqyAeEbLZ6acdaNgfD7yty5ekteIz5hRSpBBfiJi4qM0Tblndyy25rZgxl49BvUFBet46/Mnp4Je05/KtXhsFMKQAAACVBn9hFFSwj/wAAFQIvCPq7kcL+XQ17GS7yiDbbu6zbtHaitlM/AAAALwGf93RH/wAAIL/+ij9N/oFeGiDpn8dwJa1RVb6Co3HDiREMlcSgfcR07aPlaRorAAAAJAGf+WpH/wAAIK1GQr0IYOzzbZAZSchH17sZ8Sedd30ClBDdMQAAAF9Bm/5JqEFsmUwIT//98QAAAwJainJ8StfXf+jPsmUxnGHCtOzQJZLzXvtn5e6IhQYdZmMMPyNdRUdr70J2rH1sIAg6jK9IWYmcbxkJIZgRgzZe7vpvaGHCW0T6Wp3CwAAAAC1BnhxFFSwj/wAAFHIvH++1ZYGTuWjJM52obgTYMRCYp8CbLqoBUOc4zhQG6YEAAAAwAZ47dEf/AAAfyC1UpuJJ0jfK5OOeiQETkRivzz6XzI1AB7/6+UEvjKu5uDElkt0xAAAAKwGePWpH/wAAH7js2nDfPDJPnFVPxTo/jEAKjiKumc8TjW5R5c+3ozP9q9MAAABVQZoiSahBbJlMCEf//eEAAAMDub/q7ckQwIvzgCp22B2dbzyz2ln4iqzFAcx32+OHb7M4P6Ri1dIUPxxRkzxQa8NrLA51S+DNqXkT01w9HrawZKzwdAAAACdBnkBFFSwj/wAAFHs2lCPbg7vuHc6XIbEES7is7Yygq4W/hz5K7oEAAAAjAZ5/dEf/AAAfyCyipKauJMUmEZe33XrX5YwyJnXshiGEakAAAAAuAZ5hakf/AAAfxfH8wkdRj5JVxDYV/4w4XEeDK6sm3f11k49lSZ2vHLcUgnxu2QAAAFNBmmVJqEFsmUwIT//98QAAAwJJvecddV/TeB/AE9MGN+isKkzWxPkp7Fjy4ql+qOem3O6co+IYkMkwKFt+7iWxLZPq70bf/LdFMhflCa+gDk988AAAAD1BnoNFFSwj/wAAE+IvH++1nG2UH9Ec1esPVMmfLKHZN7HaOvM+gu8H7/D/OzMtpC0Xf1o4CgQtmr+Xsl2ZAAAAJAGepGpH/wAAHwjtiswHM9YYv51wY345o4kgV+JODVLbwXJZgQAAAGlBmqlJqEFsmUwIR//94QAAAwOjqGYzk7HVSoH7xFeNiF1mAFrxHiDlR5dj/lQsqwalxYK+F25T9kvsfFS3nfZUZOaFD0xcn9TnMuiYtSayeAFPuVTppSNNKtbzE24cUFGfcxfbHtyKrIkAAAApQZ7HRRUsI/8AABPiRCpWA7kciqTLKIuEclFWtn/LCV9tiuL5x6l4BYEAAAA6AZ7mdEf/AAAfGCyipHHvdfFe5lrTUmZRdeS1bqsHZDg/51m3ja6wTq1G+L2uAE1Xh/o7r8IjHUYjsAAAADABnuhqR/8AAB8I7OffZLMOH/XEVF7bzLGDXkxVRUDfbnRQAVz01QLQX64KcnmZ9ekAAACFQZrtSahBbJlMCEf//eEAAAMDo7/qaNbNRHAEcTcuTR0BhfEOuJVKMlbmed4QNxDGGewrE1PRBOpTdYzGknZjSDhEz8aNv43aD/fakhc7gQieBe7N7VO5KZ2kcdS8aP3V3EpWOmKI4xblIGpy/w/4XFhZCFP7XNx6Sq5yoyxc832fprpAZwAAADFBnwtFFSwj/wAAE+UlOJwQvUfiIr6qDMnVlNuKmojd1tETEhzqwsbtkZUSqF1QvePmAAAALwGfKnRH/wAAHwiNjcYgc2pY1mE3UgR0AJLr2x5gToYhhetlFOBxsEudwft133lAAAAAKgGfLGpH/wAAHjGKXc24Y3/IocrUCTy3upcNgGJSTcgbwvu/c8KxcRv5gQAAAH1BmzFJqEFsmUwIR//94QAAAwONv+po+Ybp9XfqGywBobT7+qoEQ9LFAAcI2kVAad2+gNWFS8gO2IMhDyXXe+mNM/ZEk1yNJWEzKOR1aclQM4CGpEkCFl5ExuexohdC2vAaukQDvliJMenGnNgcc+BDmkbsA/W57PtsGmMvtwAAACpBn09FFSwj/wAAE1Xvj4q3xwXCB+qAFt4b/qss3tAZXU8my9C1YBOeO0EAAAA7AZ9udEf/AAAeVnJAjpTqNjlPuPJyeGeGOIxHBtaN75b/tlsomoABOB4avz+AnbCGSTuU0jqviYeJ8MAAAAA5AZ9wakf/AAAeXIuwJAh+zrLt14tw0v7gY5QXrHebVrBkl4uAh0hQAfYSpGyPpN7B4ZsDixVSHPtAAAAAVEGbc0moQWyZTBRMI//94QAAAwN0Cl9IVLRGKsrrAlwBIkG6WS60JuVhFNfJ1iz6RN1be4WoekgTQWvooDLof0lX+0W3o58XOFqxWDE3EfbutLglqQAAAE4Bn5JqR/8AAB2o7Npw7YSAALY2zPxtjQ0kgTBWndJ/vmtcGw4poq7YSxkQemnBmfykQnSFxJbWSFnbW8S05R7EQS8V2abM/t9pW0qcH+AAAABpQZuXSeEKUmUwIR/94QAAAwN3v+rQerEc/TXqpv7piRURJkAGevTOBvs0tJkBunsqrdNn55gmCjbgyzqfvvOVlshJp/wvuhAZW+0FJLOib5rBathLvJqN+bwPKQ04pPR9TMbDU+HLeeC4AAAAMUGftUU0TCP/AAAS3UCgeV00NK6EKvgV/XHIiepyE1jo1/TFPJT8ojzND4WIkhNXx+8AAAAxAZ/UdEf/AAAdt25VTnoIbiA3bSoqehrM7ASFeH6Da4PRVaQAEB7mm12gfuoTEddJNAAAACIBn9ZqR/8AAB22Y2epJjgU4J3I3uQLwyBdBhPJU13D6QWBAAAAdkGb2UmoQWiZTBTwj/3hAAADA14nKc8MWqqIHU+YAewohWQzLReL3U9ez78emGNB2BMmDcGjesPu96x58eYBrDWubj6ATfhwJ2ZghoCF/YWJAqEZ5X56cCacvUu8a45UXHoaUHvhR+S3MB65oNsJ+FRHXswxPEEAAAAsAZ/4akf/AAAc+AXVeyimQAszMk0hDhee0x0lhA1oEGk9ckUGgaL6O0L2DKYAAABxQZv9SeEKUmUwIT/98QAAAwId0TXxJyWIKeeAL7EkKGPXutw60klbEWtRc7pjdkWom7KbDPnFTePb2o3D0D1EBn3C2QQgvSdcNTjNEATPrHYOYuYESwZ5pUUYSbodeZH/8zbcyaECmWCPrlD3PP2eNUEAAAA1QZ4bRTRMI/8AABJV+DMVsdgQhG0rJkD2P8B9h1aFSdgLK9JSpivxaEAJqbnaQ7NI+UBdfVAAAAAtAZ46dEf/AAAdB25iEtjm9us53lNeP9/n2FGHIvcKM1BGxsR6zi4rKy7m731RAAAAJAGePGpH/wAAHPyJHA7ojFlqeTIz+7JfOvU7MJy6xTCmcmxg4QAAAIVBmiFJqEFomUwIT//98QAAAwIJwJ1Ueyzme+OH1Jpuy/zMRrxR/fz0nVRWneJEAROzS//2UzyCG9cEp/25nlJvucu47c5WG7N6+zm50slTeWqv+stnm83bRSFBbT6ti3gH/ZXZ8f5dHgLqXsf0qrtL57EZyU5r7IWNpxTYc5eRZviQF84NAAAAOEGeX0URLCP/AAAR1fgzFbG2jhfy6ks3Maq8yEm55iXCyXXzTd+8zI2Aisw8YFK1BLMQfOAW9GHgAAAANAGefnRH/wAAHFduVU56DvZJl1hxRZQ62Lqa7Z0sgN1OayelVYYg3TPZ9Zutyxeqx2qYrlEAAAAoAZ5gakf/AAAcSAX18OZha+5N6JWpvsaIyS+njOhxePywSfZkRvMWHgAAAEpBmmVJqEFsmUwIR//94QAAAwNPv+ppPk08bQ3RmG735uRrgRq4zkboQsFgPbbrwo4eb5DRbqwyYd7a1k4LBE2KdgTDZ8bsNJJmvQAAADJBnoNFFSwj/wAAEdfxQGzPmGHMcdzbdDZw/uf14GN6SFXDOJGeRkZsdBGzXiHvQOM0gAAAACYBnqJ0R/8AABxIjM7OGxtJexEMIZfjnvhdUbCJ+rQmUghJd+E/NQAAAC8BnqRqR/8AABubg2t7JzdcV/r93BsPaoUCYG58ZmINs33sGuogOoub2BOQHYJ9fwAAAFxBmqhJqEFsmUwIT//98QAAAwH93/XxFeXVV/gCPYpvh0QMdYsksCAbN2xJ74jyY8J7bQFpwVu66ggjrZYBiXEHohWb8p8TvAVsuIE/cWbyM0TS044M/bGMIjoXQQAAACVBnsZFFSwj/wAAEV0lVAM7oGWYkp9JRePFIP81RsOiC3Hf8pzhAAAALAGe52pH/wAAG59hG0EL1WjjERSgBJeBB1Vxk/i+QRsulYh3xjXuucy/yUYVAAAAhkGa7EmoQWyZTAhP//3xAAADAfESQE3sN6UgGuENnF3QAfNYYW9YtOHzRbJbrLaHaL/w65pW0bf/icu+QOacXsn9EMDBsnVHb0zb9giAvknC+WjfPbZRNYpGFyjY8ra2vpRFgwvnb4tFWXVNlIkC3sC1M5MxoSyxBxsolT/lPy855pvf1/dQAAAANkGfCkUVLCP/AAAQ1fgzFbG2zxHzhPNI5XtA71nMla3MTTeIbTiGflwntlHKrevhfeZjzdnA+QAAADIBnyl0R/8AABr5wqQFQngGWGmWUzDGB5CN5WmElR6jFOXz1fU/CAMCZkZAybdLxxVycwAAADYBnytqR/8AABr7g4vw52ZsDYJoiFvepTABXxuo3wTHiAYESALrM50oAFeAT/bz04Mvpak1B8AAAABWQZswSahBbJlMCEf//eEAAAMDDvkMeeGdQAZnevz5Z2aeWU/Mrr8ts6TXud2fn7Wtfc15aHEOjaKXLtNRcrXYtbxtKtI5AtgO6eOAZk1sr6NOwGvTU4EAAABFQZ9ORRUsI/8AABBWANMd2ba4dOKUog9wyN4FAYAWEiKTnErWceR/Zy96k7CsNZF57dU3cYfBcQZnI+TpLArOUOpR12snAAAAMQGfbXRH/wAAGlnDEeuCVjbSgFfJYJIwEQTF5BhuoASYMgQt+NElxBhtnxix9hGOeTMAAAAkAZ9vakf/AAAaW8cNUeeIb8xHsgzEiZFwNMOJMK4N2cIxbRZTAAAASkGbckmoQWyZTBRMf/yEAAAL/v9018oGfANiy3dbrrM7griDL3ji7ozjikteqKCyVH51i205b+mYSAp5DLuKMNXGP1ijytTBp55AAAAAJQGfkWpH/wAAGl9hHA8dUrFintM9ruD1xFJ30Pxo9Y41y1cpZOEAAABFQZuTSeEKUmUwIR/94QAAAwL6JLVYBxD6unzHa6kC+HsiRjLX4+v1uP4TrB5djSZDYTs+412f31HiZifBZ8mOliRKWP0oAAAAYUGbtknhDomUwIT//fEAAAMB3N/pOAqQj5ieo9DtiT82Iv91inTSBI72krKr/bEBUwJC8tuTN9zvCGood6Gij3c1HpCYw9YKEpJ9AUtECRJKoe6IcPtVud4DM4EaF4eYcBwAAAApQZ/URRE8I/8AAA/jcPo4nmsY9w7nS5DYhAagA/oRvf09D+f911IWY4EAAAAiAZ/1akf/AAAZx5eTlDdT1avUrEDvxBY3iTzdb8ZcQRrQMAAAAG9Bm/pJqEFomUwI//yEAAALZxy6c8tfybB8/VuHMizUa3pl36NEr5b+KGzIDS5PZV3jypqAPxoj01/UbhgtXU8mflV3sZTdhGkMoS3AZNcEUfnQ1PHErspIXkKXZ/P+sPntCYDOnr/3THPq23YWGYEAAAAxQZ4YRREsI/8AAA+GVVVY6e8XYQ3tlEJJTx9AC2nBAdMDerWS9APcNDK7NWEpRg+7NwAAADABnjd0R/8AABko90xOm+bXhdfvGCuULX3rtFxi6eC8XPa7N68ScXSCpoEv1MNuaeAAAAAnAZ45akf/AAAZG4NwbDYQRWNH6k15dF1puitIWou5bEplmlhYXOM9AAAAeEGaO0moQWyZTAhH//3hAAADAtTAXGf+voA28LStBGRooVAq8rG2tRiqcxYwWY3usEqFhbUKgYTfVMJeh6obuQGjudIPrhPVq1YnOOIKTX2EF4rXzO40xfdEwU68yzY/z4rZ61dH8hFmqevNDP5ZZOs9uia8eePA6QAAAFZBml9J4QpSZTAj//yEAAALHxy6dFjfWz2o57V4nyIRmjrsdMoS501jqfYgEpCX/LyC10G/uRpBC/3WGPOJejItOTmm9qElSXvHPfHV+c3BAgdA2UCuXwAAADxBnn1FNEwj/wAADzOKsJjuHaZ4WXjPqX80ETbbKuOcoVAB76bUI91WjYU9qgJW+ZArgfzDP7xiXUux04EAAAA9AZ6cdEf/AAAYiPdMTvmta4itPQfUhIh8UyWq287tHmZCfQxguWBETzw90VTUIreY3rs5+JKOPWjpVYrOYAAAAD0Bnp5qR/8AABiHl6KDhNBUoLNxWFcKZo5ME+dTbg6FFOnu4Z/Ablu0wWyZ4r/D9VMAH2D2286Ie9mBBMjgAAAAP0GagEmoQWiZTAhH//3hAAADAsOYiUclts6q85EcQAAVW5xLLt50TqaL6C6ra+GUmZnGcpaK57QBmX1z61vjNwAAAFlBmqNJ4QpSZTAhH/3hAAADAsfJ7lkcBun4F2TjgrBV9JUatKvyDNAK2RgtooJ3La/UaY5s1Uf8BVC4MMyzBj+Z/tRbzFVB4JMiWly+WddTU/aZDefrLMYFeAAAACdBnsFFNEwj/wAADtt9Uk1eaxj3DudLkNiHvcUlyOcnQ6jeQlahaSEAAAA2AZ7iakf/AAAX28bwbDCP79z6adjURQYD3/U0bVG7N+aPCHvaUkd1F286GBTIpmFWy0Yu7bpIAAAAaEGa5UmoQWiZTBTwn/3xAAADAa8onpraF54s0H1A6kUS1HFguAsbtZxmImv5rcsr3AAmd9Ap7z6qHNvGrgcHGnFKi5Hn1RSiBJfPzsoG/TlVQzmLfvTU/2DSrgEACn8S4v3TsK/qS9tpAAAAKgGfBGpH/wAAF0tjnfMVbVzLbNMypIejvhVapjQfiUF0eoRBM/sCI8URNQAAADpBmwlJ4QpSZTAhH/3hAAADArXJ7lnITSfE3xAa+r4uWeBB9NCkruVHRvD8nGzTeDJzUW2iEu/Brq7ZAAAAJEGfJ0U0TCP/AAAOf/HO4ypLP/3itSiZdCRXrOdpAiqniT8YXQAAAB4Bn0Z0R/8AABc/eywlQg0OqYx4IRpxqDt54FGggtwAAAAuAZ9Iakf/AAAWsYAyQQl7f+P3TLPaEjvvQchaDXrO4TCOm+W5pcxHw+DIItjdUAAAAF1Bm01JqEFomUwIR//94QAAAwKj62RCv79iWrRgZOSrAEZBdEkw8eGi4KvwWX1HG9JGp3quXIorfvVTaGIjRUHOvnqbhhY2d/EQCo3Fwgu+iL8iZctmD8HgrI5DPUkAAACPQZ9rRREsI/8AAA4n6kBV8siD5GZi6XbJqoAZ9UThsoOSVPtKpVZxarR4JE07g/oUiW8vccKXxz9s+PYeEjgMK2KEH53H7ZK4GpgESN8Qd3oWajKEX5NNDAVmHzogu4nSVL3RUod1aMshkQpPX6tOJQqNlfY6T2hLe2+IqjEH3V9avM/wj4U+pSMzcoh0UeAAAABSAZ+KdEf/AAAWr3s60/gBLMX5ZKSYGTP2LzU14SUqXhO0uZ2Y1NusNZoC3AC3rARv4Nb3U8oMAvNo9KgXc89V8ydgAds27Vd0obTmybHPKsnBnAAAADABn4xqR/8AABYrY24Bt8CGczG7ev1JEUDQBGB/LhJENkygspR/Md7o7f1hHySc0bkAAAAWQZuOSahBbJlMCP/8hAAAAwAAAwDAgQAACZdtb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAALLAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAIwXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAALLAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAACWAAAAZAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAACywAAAIAAAEAAAAACDltZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAADIAAACPAFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAAfkbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAAHpHN0YmwAAACYc3RzZAAAAAAAAAABAAAAiGF2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAACWAGQAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAAyYXZjQwFkAB//4QAZZ2QAH6zZQJgz5eEAAAMAAQAAAwBkDxgxlgEABmjr48siwAAAABhzdHRzAAAAAAAAAAEAAACPAAABAAAAABRzdHNzAAAAAAAAAAEAAAABAAAEWGN0dHMAAAAAAAAAiQAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAIAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAIAAAAAAQAABAAAAAACAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAI8AAAABAAACUHN0c3oAAAAAAAAAAAAAAI8AAARsAAAApgAAADYAAAAiAAAAIgAAAOwAAABHAAAAOAAAACQAAABtAAAAUQAAACQAAAAmAAAAUAAAADoAAAAmAAAAKAAAAHsAAAA+AAAAKQAAADcAAABbAAAALAAAACkAAAAsAAAAdAAAADsAAAAoAAAAOQAAAGUAAAAuAAAALwAAACsAAABmAAAALAAAADMAAAAmAAAAZgAAACoAAAAoAAAAJwAAAG0AAAAuAAAAMAAAAIIAAAA8AAAAMwAAADoAAAAvAAAAOAAAADYAAABdAAAAMwAAADQAAAArAAAAcwAAACkAAAAzAAAAKAAAAGMAAAAxAAAANAAAAC8AAABZAAAAKwAAACcAAAAyAAAAVwAAAEEAAAAoAAAAbQAAAC0AAAA+AAAANAAAAIkAAAA1AAAAMwAAAC4AAACBAAAALgAAAD8AAAA9AAAAWAAAAFIAAABtAAAANQAAADUAAAAmAAAAegAAADAAAAB1AAAAOQAAADEAAAAoAAAAiQAAADwAAAA4AAAALAAAAE4AAAA2AAAAKgAAADMAAABgAAAAKQAAADAAAACKAAAAOgAAADYAAAA6AAAAWgAAAEkAAAA1AAAAKAAAAE4AAAApAAAASQAAAGUAAAAtAAAAJgAAAHMAAAA1AAAANAAAACsAAAB8AAAAWgAAAEAAAABBAAAAQQAAAEMAAABdAAAAKwAAADoAAABsAAAALgAAAD4AAAAoAAAAIgAAADIAAABhAAAAkwAAAFYAAAA0AAAAGgAAABRzdGNvAAAAAAAAAAEAAAAwAAAAYnVkdGEAAABabWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAbWRpcmFwcGwAAAAAAAAAAAAAAAAtaWxzdAAAACWpdG9vAAAAHWRhdGEAAAABAAAAAExhdmY1OC4yOS4xMDA=\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/double_q\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
